package com.ruoyi.littleRedBook.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.littleRedBook.domain.pojo.Order;
import com.ruoyi.littleRedBook.domain.pojo.Product;
import com.ruoyi.littleRedBook.domain.pojo.Review;
import com.ruoyi.littleRedBook.domain.pojo.UserAddress;
import com.ruoyi.littleRedBook.mapper.*;
import com.ruoyi.littleRedBook.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.UUID;

@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private UserAddressMapper userAddressMapper;

    @Autowired
    private ReviewMapper reviewMapper;

    @Autowired
    private UserMapper userMapper;

    // 实际项目中从Token/Session获取当前登录用户ID，此处占位示例
    private Long getCurrentUserId() {
        return 1L; // 需替换为真实的当前用户ID获取逻辑（如JWT解析）
    }

    /**
     * 生成订单核心逻辑：
     * 1. 校验商品状态（审核通过、未售出）
     * 2. 校验收货地址归属
     * 3. 生成唯一订单号
     * 4. 填充订单基础信息（买家、卖家、金额等）
     * 5. 保存订单 + 更新商品状态为已售出
     */
    @Override
    public AjaxResult createOrder(Order order) {
        // 1. 校验必填参数
        Long productId = order.getProductId();
        Long addressId = order.getAddressId();
        if (productId == null || addressId == null) {
            return AjaxResult.error("商品ID和收货地址ID为必填项");
        }

        // 2. 校验商品状态（必须审核通过、未售出）
        Product product = productMapper.selectById(productId);
        if (product == null) {
            return AjaxResult.error("商品不存在");
        }
        if (product.getStatus() != 1) { // 1-审核通过
            return AjaxResult.error("商品未上架或已售出，无法下单");
        }

        // 3. 校验收货地址归属（地址必须属于当前买家）
        Long buyerId = getCurrentUserId();
        UserAddress address = userAddressMapper.selectById(addressId);
        if (address == null || !address.getUserId().equals(buyerId)) {
            return AjaxResult.error("收货地址不存在或无权限使用");
        }

        // 4. 填充订单信息
        Order newOrder = new Order();
        // 生成唯一订单号（UUID截取+时间戳，确保唯一性）
        String orderNo = "ORDER_" + System.currentTimeMillis() + "_" + UUID.randomUUID().toString().substring(0, 8);
        newOrder.setOrderNo(orderNo);
        newOrder.setBuyerId(buyerId);
        newOrder.setSellerId(product.getSellerId()); // 商品卖家即订单卖家
        newOrder.setProductId(productId);
        newOrder.setAddressId(addressId);
        newOrder.setQuantity(1); // 二手商品默认1件，如需多件可扩展
        newOrder.setTotalAmount(product.getPrice()); // 订单金额=商品价格（无折扣场景）
        newOrder.setStatus(0); // 0-待付款
        newOrder.setCreatedAt(LocalDateTime.now());
        newOrder.setUpdatedAt(LocalDateTime.now());

        // 5. 保存订单 + 更新商品状态为已售出（4）
        int orderRows = orderMapper.insert(newOrder);
        if (orderRows <= 0) {
            return AjaxResult.error("订单创建失败");
        }
        product.setStatus(4); // 4-已售出
        productMapper.updateById(product);

        return AjaxResult.success("订单创建成功", newOrder);
    }

    /**
     * 买家视角：按状态获取订单列表
     * 支持状态：0-待付款、2-待收货
     */
    @Override
    public AjaxResult getOrdersByStatus(Integer status, Integer pageNum, Integer pageSize) {
        // 校验状态合法性（仅支持买家相关状态）
        if (!status.equals(0) && !status.equals(2)) {
            return AjaxResult.error("不支持的订单状态");
        }

        Long buyerId = getCurrentUserId();
        Page<Order> page = new Page<>(pageNum, pageSize);
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("buyer_id", buyerId)
                    .eq("status", status)
                    .orderByDesc("created_at"); // 按创建时间倒序

        Page<Order> orderPage = orderMapper.selectPage(page, queryWrapper);
        return AjaxResult.success(orderPage.getRecords());
    }

    /**
     * 卖家视角：按状态获取订单列表
     * 支持状态：1-待发货
     */
    @Override
    public AjaxResult getSellerOrdersByStatus(Integer status, Integer pageNum, Integer pageSize) {
        // 校验状态合法性（仅支持卖家相关状态）
        if (!status.equals(1)) {
            return AjaxResult.error("不支持的订单状态");
        }

        Long sellerId = getCurrentUserId();
        Page<Order> page = new Page<>(pageNum, pageSize);
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("seller_id", sellerId)
                    .eq("status", status)
                    .orderByDesc("created_at");

        Page<Order> orderPage = orderMapper.selectPage(page, queryWrapper);
        return AjaxResult.success(orderPage.getRecords());
    }

    /**
     * 确认收货逻辑：
     * 1. 校验订单归属（买家）
     * 2. 校验订单状态（必须是待收货2）
     * 3. 更新订单状态为已完成3 + 记录确认收货时间
     */
    @Override
    public AjaxResult confirmReceive(Long orderId) {
        // 1. 校验订单存在性
        Order order = orderMapper.selectById(orderId);
        if (order == null) {
            return AjaxResult.error("订单不存在");
        }

        // 2. 校验订单归属（必须是当前买家的订单）
        Long buyerId = getCurrentUserId();
        if (!order.getBuyerId().equals(buyerId)) {
            return AjaxResult.error("无权限操作此订单");
        }

        // 3. 校验订单状态（必须是待收货2）
        if (!order.getStatus().equals(2)) {
            return AjaxResult.error("仅待收货订单可确认收货");
        }

        // 4. 更新订单信息
        order.setStatus(3); // 3-已完成
        order.setReceiveTime(LocalDateTime.now());
        order.setUpdatedAt(LocalDateTime.now());
        int rows = orderMapper.updateById(order);

        return rows > 0 ? AjaxResult.success("确认收货成功") : AjaxResult.error("确认收货失败");
    }

    /**
     * 取消订单逻辑：
     * 1. 校验订单归属
     * 2. 校验订单状态（仅待付款0可取消）
     * 3. 更新订单状态为已取消4 + 记录取消原因和时间
     * 4. 恢复商品状态为审核通过1（订单取消后商品可重新上架）
     */
    @Override
    public AjaxResult cancelOrder(Long orderId, String cancelReason) {
        // 1. 校验取消原因非空
        if (StringUtils.isEmpty(cancelReason)) {
            return AjaxResult.error("取消原因不能为空");
        }

        // 2. 校验订单存在性
        Order order = orderMapper.selectById(orderId);
        if (order == null) {
            return AjaxResult.error("订单不存在");
        }

        // 3. 校验订单归属（买家可取消自己的待付款订单）
        Long buyerId = getCurrentUserId();
        if (!order.getBuyerId().equals(buyerId)) {
            return AjaxResult.error("无权限操作此订单");
        }

        // 4. 校验订单状态（仅待付款0可取消）
        if (!order.getStatus().equals(0)) {
            return AjaxResult.error("仅待付款订单可取消");
        }

        // 5. 更新订单信息
        order.setStatus(4); // 4-已取消
        order.setCancelReason(cancelReason);
        order.setCancelTime(LocalDateTime.now());
        order.setUpdatedAt(LocalDateTime.now());
        int orderRows = orderMapper.updateById(order);
        if (orderRows <= 0) {
            return AjaxResult.error("取消订单失败");
        }

        // 6. 恢复商品状态为审核通过1（可重新上架）
        Product product = productMapper.selectById(order.getProductId());
        if (product != null) {
            product.setStatus(1); // 1-审核通过
            productMapper.updateById(product);
        }

        return AjaxResult.success("取消订单成功");
    }

    /**
     * 获取订单详情：
     * 校验订单归属（买家或卖家均可查看自己的订单）
     */
    @Override
    public AjaxResult getOrderDetail(Long orderId) {
        // 1. 校验订单存在性
        Order order = orderMapper.selectById(orderId);
        if (order == null) {
            return AjaxResult.error("订单不存在");
        }

        // 2. 校验订单归属（当前用户是买家或卖家）
        Long currentUserId = getCurrentUserId();
        if (!order.getBuyerId().equals(currentUserId) && !order.getSellerId().equals(currentUserId)) {
            return AjaxResult.error("无权限查看此订单");
        }

        return AjaxResult.success(order);
    }

    /**
     * 订单评价逻辑：
     * 1. 校验订单存在性及归属（买家评价卖家）
     * 2. 校验订单状态（必须已完成3）
     * 3. 校验订单未被评价（数据库有唯一约束，此处先校验）
     * 4. 填充评价信息并保存
     */
    @Override
    public AjaxResult addOrderReview(Review review) {
        // 1. 校验必填参数
        Long orderId = review.getOrderId();
        Integer rating = review.getRating();
        if (orderId == null || rating == null) {
            return AjaxResult.error("订单ID和评分为必填项");
        }
        if (rating < 1 || rating > 5) {
            return AjaxResult.error("评分必须为1-5分");
        }

        // 2. 校验订单存在性及状态（必须已完成3）
        Order order = orderMapper.selectById(orderId);
        if (order == null) {
            return AjaxResult.error("订单不存在");
        }
        if (!order.getStatus().equals(3)) {
            return AjaxResult.error("仅已完成订单可评价");
        }

        // 3. 校验评价归属（必须是当前买家评价）
        Long reviewerId = getCurrentUserId(); // 评价人=当前买家
        if (!order.getBuyerId().equals(reviewerId)) {
            return AjaxResult.error("无权限评价此订单");
        }

        // 4. 校验订单未被评价（避免重复评价）
        QueryWrapper<Review> reviewWrapper = new QueryWrapper<>();
        reviewWrapper.eq("order_id", orderId);
        Review existingReview = reviewMapper.selectOne(reviewWrapper);
        if (existingReview != null) {
            return AjaxResult.error("此订单已评价，不可重复评价");
        }

        // 5. 填充评价信息
        Review newReview = new Review();
        newReview.setOrderId(orderId);
        newReview.setReviewerId(reviewerId);
        newReview.setReviewedId(order.getSellerId()); // 被评价人=卖家
        newReview.setProductId(order.getProductId());
        newReview.setRating(rating);
        newReview.setContent(review.getContent()); // 评价内容（可为空）
        newReview.setIsAnonymous(review.getIsAnonymous() == null ? 0 : review.getIsAnonymous()); // 默认实名
        newReview.setCreatedAt(LocalDateTime.now());
        newReview.setUpdatedAt(LocalDateTime.now());

        // 6. 保存评价
        int rows = reviewMapper.insert(newReview);
        return rows > 0 ? AjaxResult.success("评价提交成功", newReview) : AjaxResult.error("评价提交失败");
    }

    /**
     * 获取订单对应的评价：
     * 买家/卖家均可查看订单评价
     */
    @Override
    public AjaxResult getOrderReview(Long orderId) {
        // 1. 校验订单存在性及归属
        Order order = orderMapper.selectById(orderId);
        if (order == null) {
            return AjaxResult.error("订单不存在");
        }
        Long currentUserId = getCurrentUserId();
        if (!order.getBuyerId().equals(currentUserId) && !order.getSellerId().equals(currentUserId)) {
            return AjaxResult.error("无权限查看此订单评价");
        }

        // 2. 查询评价
        QueryWrapper<Review> reviewWrapper = new QueryWrapper<>();
        reviewWrapper.eq("order_id", orderId);
        Review review = reviewMapper.selectOne(reviewWrapper);

        return AjaxResult.success(review);
    }
}
